We have an image. Now for some Filter Fun! Mostly we want to see how mixing images with near neighbor pixels changes the images



In [1]:

    
%pylab inline
import random
img = imread('imgs/firestar.png')
img[0]
img[1]
img[2]
img[4]









    



Populating the interactive namespace from numpy and matplotlib






    Out[1]:





array([[ 1.        ,  1.        ,  0.96078432],
       [ 1.        ,  1.        ,  0.96078432],
       [ 1.        ,  1.        ,  0.96078432],
       ..., 
       [ 0.64313728,  0.52941179,  0.39607844],
       [ 0.68235296,  0.57254905,  0.42745098],
       [ 0.70980394,  0.59215689,  0.4509804 ]], dtype=float32)

We start out with 2D arrays, that seem to the number of rows in the image. Each row indicates the RGB value of the underlying pixels



In [12]:

    
imgplot = plt.imshow(img) # This is what we started with.



In [13]:

    
print len(img), len(img[0]), len(img[0][0]), img [0][0] # this is what we have









    



1087 812 3 [ 1.          1.          0.96078432]



In [14]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            img[i][j][k] = 0.0
            k += 1
        j += 1
    i += 1
        

print len(img), len(img[0]), len(img[0][0]), img [0][0]









    



1087 812 3 [ 0.  0.  0.]



In [15]:

    
imgplot = plt.imshow(img) # We can control the color of each pixel



In [28]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0]):
                img[i][j][k] = img[i][j][k] + 0.1*img[i][j-1][k]
            k += 1
        j += 1
    i += 1



In [29]:

    
imgplot = plt.imshow(img) # Mixing pixels with the ones below



In [36]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                img[i][j][k] = img[i][j][k] + 0.1*img[i][j-1][k] - 0.1*img[i][j+1][k]
            k += 1
        j += 1
    i += 1



In [37]:

    
imgplot = plt.imshow(img) # Mixing pixels with the ones above and below below



In [16]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 3 and i < len(img) and j < len(img[0])-3:
                img[i][j][k] = img[i][j][k] + 0.1*img[i][j-3][k] - 0.1*img[i][j+3][k]
            k += 1
        j += 1
    i += 1



In [17]:

    
imgplot = plt.imshow(img) # Now from further away in both directions



In [20]:

    
img = imread('imgs/firestar.png')
i = len(img)-1
j = len(img[0])-1
k = len(img[0][0])-1
while i >= 0 :
    j = len(img[0])-1
    while j >= 0 :
        k = len(img[0][0])-1
        while k >= 0 :
            if i > 0 and j > 3 and i < len(img) and j < len(img[0])-3:
                img[i][j][k] = img[i][j][k] + 0.1*img[i][j-3][k] - 0.1*img[i][j+3][k]
            k = k - 1
        j = j - 1
    i = i - 1



In [21]:

    
imgplot = plt.imshow(img)  # again, but from lower right



In [38]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                if img[i][j][k] < 0.2:
                    img[i][j][k] = 0.0
                else: 
                    img[i][j][k] = 1.0
            k += 1
        j += 1
    i += 1



In [39]:

    
imgplot = plt.imshow(img) # Threshold version for something interesting.



In [40]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = i
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                if img[i][j][k] < 0.2:
                    img[i][j][k] = 0.0
                else: 
                    img[i][j][k] = 1.0
            k += 1
        j += 1
    i += 1



In [41]:

    
imgplot = plt.imshow(img) # processed along the axis



In [42]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                if img[i][j][0] < 0.2:
                    img[i][j][k] = img[i][j][0]
                else: 
                    img[i][j][k] = 0.0
            k += 1
        j += 1
    i += 1



In [43]:

    
imgplot = plt.imshow(img) # processed along the axis



In [44]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                if img[i][j][0] < 0.5:
                    img[i][j][k] = img[i][j][0]
                else: 
                    img[i][j][k] = 1.0
            k += 1
        j += 1
    i += 1



In [45]:

    
imgplot = plt.imshow(img) # Capturing the interesting red bits



In [46]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                if img[i][j][1] < 0.5:
                    img[i][j][k] = img[i][j][1]
                else: 
                    img[i][j][k] = 1.0
            k += 1
        j += 1
    i += 1



In [47]:

    
imgplot = plt.imshow(img) # Capturing the interesting green bits



In [48]:

    
img = imread('imgs/firestar.png')
i = 0
j = 0
k = 0
while i < len(img):
    j = 0
    while j < len(img[0]):
        k = 0
        while k < len(img[0][0]):
            if i > 0 and j > 0 and i < len(img) and j < len(img[0])-1:
                if img[i][j][2] < 0.5:
                    img[i][j][k] = img[i][j][2]
                else: 
                    img[i][j][k] = 1.0
            k += 1
        j += 1
    i += 1



In [49]:

    
imgplot = plt.imshow(img) # Capturing the interesting blue bits

Overall, the filter's I am most interested in using manipulate the pixel based on it's neighbors values. They are somewhat boring and thresholding produces better colors.



In [ ]: